Is there a way to get the old Logger interface so it can be restored? The new public UseLogger function does not return anything compared to the internal's UseLogger.

Without having access to the original logger, I can't perform the original functionality without copy-pasting the code from internal

I suppose we could consider adding a SwapLogger(new Logger) (old Logger) interface or something. I'm curious, what's your use case? We have the undo functionality internally for testing this library but I'm not sure how useful it would be outside of developing this library.

I'm trying to silence the internal diagnostics like INFO: Profiler configuration because they are printed to stderr, they are interpreted as errors in the DD webui. So I have a custom logger that basically says:

if !ignoring {
   originalLoggger(msg)
} else {
   // do nothing
}

Basically, in addition to implementing my own logger, I also want the option to invoke the old one based on any logic I choose.

I see, so what you're looking for is something like a GetLogger() Logger function, so you could do

orig := ddtrace.GetLogger()
ddtrace.UseLogger(Wrap(orig))

where Wrap wraps the original logger. I just want to clarify: would the original logger even be useful? If the original logger is problematic because it logs to stderr, and your logger delegates to the original one, you would still have that problem, right? Or are some logs okay to print to stderr? Either way, the logging implementation our library uses internally is somewhat arbitrary. It's just the standard library logger. Outside of testing, the destination of our log messages doesn't affect the library. Is there any benefit to having access to the original logger vs entirely using your own? Like:

if !ignoring {
    log.Println(msg) // or whichever logging library you use elsewhere in the program
}

Correct, I want a ddtrace.GetLogger()

Just from a design standpoint, it seems unusual that UseLogger is a permanent one-way operation that I can never revert, unless I have the original before that.

Yeah I looked through (I got a bit lost in the separation between log and ddtrace/internal/log) and it looks like the internal log is actually directly opening FD2 (stderr) and writing the logs to it. Which means if my custom logger needed to emulate that behavior, I would also need to open 2 or just call the original handler, something like this is what I want to do:

type struct mylogger {
    original ddtrace.Logger
    ignoring bool
}
(l *mylogger) Log(m string) {
    if !l.ignoring {
       // Just do whatever DD does normally
       l.original.Log(m)    // what I want to do
       /* what i actually need to do to emulate what dd is currently doing
       fd := os.Open(2) // or whatever
       fd.Write(m)
       */
    } else {
        fmt.Printf("* This message was ignored: %s\n", m) // or don't do anything here or some other external messaging channel
    }
}